﻿
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using System.Drawing;
//using System.Drawing.Imaging;

//namespace LowLevelGraphics.Filter
//{
//    /// <summary>
//    /// Non Maximum suppression
//    /// </summary>
//    public class NonMaximumSuppression : BaseImageFilter
//    {
//        /// <summary>
//        /// Initializes a new instance of the <see cref="NonMaximumSuppression"/> class.
//        /// </summary>
//        public NonMaximumSuppression()
//        {
//        }

//        /// <summary>
//        /// Initializes a new instance of the <see cref="NonMaximumSuppression"/> class.
//        /// </summary>
//        /// <param name="_nonMaximumSuppression">The _non maximum suppression.</param>
//        internal NonMaximumSuppression(NonMaximumSuppression _nonMaximumSuppression)
//        {
//        }

//        /// <summary>
//        /// Execute this Filter
//        /// A Debug Statement is written if a concrete Filter is called
//        /// </summary>
//        /// <param name="_bitmap"></param>
//        /// <returns></returns>
//        public override UnsafeBitmap Execute(UnsafeBitmap _bitmap)
//        {
//            int nHeight = _bitmap.Height;
//            int nWidth = _bitmap.Width;
//            //int i, j, k, n, m;
//            //int top, bottom, left, right;
//            //float xx, yy, g2, g1, g3, g4, g, xc, yc;
//            //for (i = 1; i < nHeight - 1; i++)
//            //{
//            //    for (j = 1; j < nWidth - 1; j++)
//            //    {
//            //        mag->data[i][j] = 0;
//            //        /* Treat the x and y derivatives as components of a vector */
//            //        xc = dx[i, j];
//            //        yc = dy[i, j];
//            //    }
//            //}
//            //if (Math.Abs(xc) < 0.01 && Math.Abs(yc) < 0.01) continue;
//            //g = norm(xc, yc);
//            ///* Follow the gradient direction, as indicated by the direction of
//            //the vector (xc, yc); retain pixels that are a local maximum.*/
//            //if (Math.Abs(yc) > Math.Abs(xc))
//            //{
//            //    /* The Y component is biggest, so gradient direction is basically UP/DOWN */
//            //    xx = Math.Abs(xc) / Math.Abs(yc);
//            //    yy = 1.0;
//            //    g2 = norm(dx[i - 1, j], dy[i - 1, j]);
//            //    g4 = norm(dx[i + 1, j], dy[i + 1, j]);
//            //    if (xc * yc > 0.0)
//            //    {
//            //        g3 = norm(dx[i + 1, j + 1], dy[i + 1, j + 1]);
//            //        g1 = norm(dx[i - 1, j - 1], dy[i - 1, j - 1]);
//            //    }
//            //    else
//            //    {
//            //        g3 = norm(dx[i + 1, j - 1], dy[i + 1, j - 1]);
//            //        g1 = norm(dx[i - 1, j + 1], dy[i - 1, j + 1]);
//            //    }
//            //}

//            return _bitmap;
//        }

//        /// <summary>
//        /// Norms the specified x.
//        /// </summary>
//        /// <param name="x">The x.</param>
//        /// <param name="y">The y.</param>
//        /// <returns></returns>
//        float norm(float x, float y)
//        {
//            return (float)Math.Sqrt((double)(x * x + y * y));
//        }

//        /// <summary>
//        /// Olds the code.
//        /// </summary>
//        /// <param name="_bitmap">The _bitmap.</param>
//        private static void OldCode(UnsafeBitmap _bitmap)
//        {
//            UnsafeBitmap bitmap = _bitmap;

//            int nHeight = bitmap.Height;
//            int nWidth = bitmap.Width;

//            List<Point> aPoint = Definitions.EnvironmentPointListClockwise;
//            Color[] aColor = new Color[8];

//            int[,] aInt = new int[,]{
//                {0,4},
//                {2,6},
//                {1,5},
//                {7,3}
//            };

//            int x = 0;
//            int y = 0;

//            Color color1 = Color.Transparent;
//            Color color2 = Color.Transparent;

//            Color color = Color.Transparent;

//            int nDistance = 0;
//            for (y = 0; y < nHeight; y++)
//            {
//                for (x = 0; x < nWidth; x++)
//                {
//                    color = bitmap.GetPixel(x, y);
//                    aColor = Segmentation.GetEnvironmentPixelColorArray(bitmap, x, y, aPoint, aColor);

//                    for (int i = 0; i < aInt.Length; i += 2)
//                    {
//                        color1 = aColor[i];
//                        color2 = aColor[i + 1];
//                        nDistance = ColorFunctions.Distance(color1, color2);
//                    }
//                }
//            }
//        }

//        /// <summary>
//        /// This is used to clone a filter, each filter must implement it's own clone functionality
//        /// </summary>
//        /// <returns></returns>
//        public override object Clone()
//        {
//            return new NonMaximumSuppression(this);
//        }
//    }
//}
